#ifndef __BE_TURPLE__
#define __BE_TURPLE__



template<class _X, int _S>
class Turple
{
public:
  typedef _X DataType;

  enum
    {
      SIZE = _S,
    };


private:
  DataType data[SIZE];
  float a;

  template<class _Y, int _i>
  class Arithmetic
  {
  public:
    static inline void equal( _Y &_val1, const _Y &_val2 )
    {
      Arithmetic<_Y, _i - 1>::equal( _val1, _val2);
      _val1.data[_i] = _val2.data[_i];
    }
    
    static inline void equal2( _Y _val1, const typename _Y::DataType &_val2 )
    {
      Arithmetic<_Y, _i - 1>::equal2(_val1, _val2);
      _val1.data[_i] = _val2;
    }
  };
  
  template<class _Y>
  class Arithmetic<_Y, 0>
  {
  public:
    static inline void equal( _Y &_val1, const _Y &_val2 )
    {
      _val1.data[0] = _val2.data[0];
    }

    static inline void equal2( _Y _val1, const typename _Y::DataType &_val2 )
    {
      _val1.data[0] = _val2;
    }
  };
  
  
public:
  Turple()
  {
    Arithmetic<Turple, SIZE - 1>::equal2(*this, 0);
  }

  ~Turple()
  {}

  DataType & operator[]( unsigned int _idx )
  {
    if (_idx < SIZE)
      {
	return data[_idx];
      }
    else
      {
#ifdef DEBUG
	// Output debug error message
#endif
	return data[0];
      }
  }

  void operator= ( const Turple &_val )
  {
    Arithmetic<Turple, SIZE - 1>::equal(*this, _val);
  }

  DataType operator[]( unsigned int _idx ) const
  {
    if ( _idx < SIZE )
      {
	return data[_idx];
      }
    else
      {
#ifdef DEBUG
	// Output debug message
#endif
	return 0;
      }
  }

};

#endif
